/**
 * src/app.tsx
 * ------------------------------------
 * 应用入口组件
 * 1. 初始化云开发环境与本地数据
 * 2. 提供全局状态管理 AppProvider
 * 3. 处理网络状态变化与离线数据同步
 * 4. 加载本地数据或云端数据，确保应用启动时有可用数据
 * 该文件是应用的根组件，所有页面都在此组件内渲染
 * 创建日期：2025-08-06
 */
import React, { useEffect, useState } from 'react'
import Taro from '@tarojs/taro'
import { View } from '@tarojs/components'

import { AppProvider, useAppContext } from './store'
import { CloudDataManager } from './utils/cloud'
import { DataManager, DEFAULT_DISHES, DEFAULT_CATEGORIES, DEFAULT_USERS } from './utils'
import { scheduledTasks } from './utils/scheduledTasks'
import { TimerManager } from './utils/timerManager'
import NetworkStatus from './components/NetworkStatus'

import './app.scss'

// 如果需要在 h5 环境中开启 React Devtools
// 取消以下注释：
// if (process.env.NODE_ENV !== 'production' && process.env.TARO_ENV === 'h5')  {
//   require('nerv-devtools')
// }

const AppContent = ({ children }) => {
  const { state, dispatch } = useAppContext()
  const [isOnline, setIsOnline] = useState(true)
  const [isInitialLoad, setIsInitialLoad] = useState(true)
  const [offlineSyncPending, setOfflineSyncPending] = useState(false)

  useEffect(() => {
    // 初始化数据（云开发初始化移到initializeApp中，避免重复初始化）
    initializeApp()
    
    // 添加清理函数
    return () => {
      console.log('应用即将卸载，清理资源')
      // 清理定时任务
      scheduledTasks.cleanup()
      // 清理所有定时器
      TimerManager.clearAll()
      // 停止所有监听器
      CloudDataManager.stopAllWatches()
    }
  }, [])

  const initializeApp = async () => {
    dispatch({ type: 'SET_LOADING', payload: true })

    try {
      // 检查本地存储的用户信息
      const storedUser = DataManager.getStoredUser()
      if (storedUser) {
        dispatch({ type: 'SET_USER', payload: storedUser })
      }

      // 检查网络状态
      const networkStatus = await Taro.getNetworkType()
      const isConnected = networkStatus.networkType !== 'none'
      setIsOnline(isConnected)

      // 初始化云开发（只在这里调用一次）
      const cloudInitialized = await CloudDataManager.init()

      // 如果在线且云开发初始化成功，从云端同步数据
      if (isConnected && cloudInitialized) {
        // 检查是否有离线更改需要同步
        const offlineChanges = DataManager.getOfflineChanges()
        if (offlineChanges && offlineChanges.length > 0) {
          setOfflineSyncPending(true)
          await syncOfflineChanges()
        } else {
          await syncDataWithCloud()
        }
        
        // 云开发初始化成功后，初始化定时任务
        scheduledTasks.init()
      } else {
        // 使用本地数据模式
        console.log('使用本地数据模式')
        await loadLocalData()
      }
    } catch (error) {
      console.error('应用初始化失败:', error)
      // 出错时也使用本地数据
      await loadLocalData()
    } finally {
      dispatch({ type: 'SET_LOADING', payload: false })
      setIsInitialLoad(false)
    }
  }

  // 从云端同步数据
  const syncDataWithCloud = async () => {
    try {
      // 检查是否有离线更改需要同步
      const offlineChanges = DataManager.getOfflineChanges()
      if (offlineChanges && offlineChanges.length > 0) {
        await syncOfflineChanges()
        return // syncOfflineChanges会重新加载数据
      }
      
      // 初始化示例数据（如果数据库为空）
      await CloudDataManager.initializeSampleData()
      
      // 从云端加载数据
      const dishes = await CloudDataManager.getDishes()
      const categories = await CloudDataManager.getCategories()
      const orders = await CloudDataManager.getOrders()
      
      // 更新全局状态（只在数据发生变化时）
      if (JSON.stringify(dishes) !== JSON.stringify(state.dishes)) {
        dispatch({ type: 'SET_DISHES', payload: dishes })
      }
      if (JSON.stringify(categories) !== JSON.stringify(state.categories)) {
        dispatch({ type: 'SET_CATEGORIES', payload: categories })
      }
      if (JSON.stringify(orders) !== JSON.stringify(state.orders)) {
        dispatch({ type: 'SET_ORDERS', payload: orders })
      }
      
      // 保存到本地存储
      DataManager.saveDishes(dishes)
      DataManager.saveCategories(categories)
      DataManager.saveOrders(orders)
      
      console.log('云端数据同步完成')
    } catch (error) {
      console.error('云端数据同步失败:', error)
      // 不抛出错误，而是使用本地数据
      loadLocalData()
    }
  }

  // 从本地加载数据
  const loadLocalData = async () => {
    try {
      // 获取本地存储的数据
      let dishes = DataManager.getDishes()
      let categories = DataManager.getCategories()
      let orders = DataManager.getOrders()
      
      // 如果本地没有数据，使用默认示例数据
      if (dishes.length === 0) {
        console.log('本地无菜品数据，使用默认示例数据')
        dishes = DEFAULT_DISHES
        DataManager.saveDishes(dishes)
      }

      if (categories.length === 0) {
        console.log('本地无分类数据，使用默认示例数据')
        categories = DEFAULT_CATEGORIES
        DataManager.saveCategories(categories)
      }

      // 初始化用户数据
      const users = DEFAULT_USERS;
      
      // 保存用户数据到本地存储
      users.forEach(user => {
        DataManager.saveUser(user)
      })

      // 更新全局状态（只在数据发生变化时）
      if (JSON.stringify(dishes) !== JSON.stringify(state.dishes)) {
        dispatch({ type: 'SET_DISHES', payload: dishes })
      }
      if (JSON.stringify(categories) !== JSON.stringify(state.categories)) {
        dispatch({ type: 'SET_CATEGORIES', payload: categories })
      }
      if (JSON.stringify(orders) !== JSON.stringify(state.orders)) {
        dispatch({ type: 'SET_ORDERS', payload: orders })
      }
      
      // 只在没有当前用户时设置用户
      if (users.length > 0 && !state.currentUser) {
        const currentPath = window.location.pathname
        if (currentPath.includes('/guest/')) {
          // 如果是客人页面，设置为客人用户
          const guestUser = users.find(user => user.role === 'guest')
          if (guestUser) {
            dispatch({ type: 'SET_USER', payload: guestUser })
          } else {
            dispatch({ type: 'SET_USER', payload: users[0] })
          }
        } else {
          // 默认设置为厨师用户
          dispatch({ type: 'SET_USER', payload: users[0] })
        }
      }

      console.log('本地数据加载完成，菜品数量:', dishes.length)
      console.log('本地数据加载完成，分类数量:', categories.length)
      console.log('本地数据加载完成，用户数量:', users.length)
    } catch (error) {
      console.error('加载本地数据失败:', error)
    }
  }

  // 同步离线更改
  const syncOfflineChanges = async () => {
    try {
      dispatch({ type: 'SET_LOADING', payload: true })
      const offlineChanges = DataManager.getOfflineChanges()
      console.log(`开始同步 ${offlineChanges.length} 个离线变更`)
      
      const changesByCollection: Record<string, any[]> = {}
      
      // 按集合分组变更
      offlineChanges.forEach(change => {
        if (!changesByCollection[change.collection]) {
          changesByCollection[change.collection] = []
        }
        changesByCollection[change.collection].push(change)
      })
      
      // 处理每个集合的变更
      for (const collection of Object.keys(changesByCollection)) {
        const changes = changesByCollection[collection]
        
        // 获取云端最新数据
        let cloudData: any[] = []
        switch (collection) {
          case 'dishes':
            cloudData = await CloudDataManager.getDishes()
            break
          case 'orders':
            cloudData = await CloudDataManager.getOrders()
            break
          case 'categories':
            cloudData = await CloudDataManager.getCategories()
            break
          default:
            cloudData = await CloudDataManager.getAllData(collection, {})
        }
        
        // 处理每个变更
        for (const change of changes) {
          try {
            switch (change.type) {
              case 'add':
                // 检查是否已存在（可能已在其他设备上添加）
                const existingItem = cloudData.find(item => {
                  // 如果本地生成的临时ID，则检查其他字段
                  if (change.id.startsWith('local_')) {
                    if (collection === 'dishes') {
                      return item.name === change.data.name
                    } else if (collection === 'orders') {
                      return item.createdAt === change.data.createdAt && 
                             item.userId === change.data.userId
                    } else if (collection === 'categories') {
                      return item.name === change.data.name
                    }
                  }
                  return item.id === change.id
                })
                
                if (!existingItem) {
                  // 不存在，添加到云端
                  switch (collection) {
                    case 'dishes':
                      await CloudDataManager.saveDish(change.data)
                      break
                    case 'orders':
                      await CloudDataManager.saveOrder(change.data)
                      break
                    case 'categories':
                      await CloudDataManager.saveCategory(change.data)
                      break
                    default:
                      await CloudDataManager.addData(collection, change.data)
                  }
                  console.log(`同步添加成功: ${collection} ${change.id}`)
                } else {
                  console.log(`数据已存在，跳过添加: ${collection} ${change.id}`)
                }
                break
                
              case 'update':
                // 检查云端是否存在此项
                const cloudItem = cloudData.find(item => item.id === change.id)
                
                if (cloudItem) {
                  // 比较时间戳，确定使用哪个版本
                  const cloudUpdateTime = new Date(cloudItem.updatedAt).getTime()
                  const localUpdateTime = change.timestamp
                  
                  if (localUpdateTime >= cloudUpdateTime) {
                    // 本地更新更新或相同，应用本地变更
                    switch (collection) {
                      case 'dishes':
                        await CloudDataManager.saveDish(change.data)
                        break
                      case 'orders':
                        await CloudDataManager.saveOrder(change.data)
                        break
                      case 'categories':
                        await CloudDataManager.saveCategory(change.data)
                        break
                      default:
                        await CloudDataManager.updateData(collection, change.id, change.data)
                    }
                    console.log(`同步更新成功: ${collection} ${change.id}`)
                  } else {
                    console.log(`云端数据较新，保留云端版本: ${collection} ${change.id}`)
                  }
                } else {
                  console.warn(`要更新的数据不存在: ${collection} ${change.id}`)
                }
                break
                
              case 'delete':
                // 检查云端是否存在此项
                const itemToDelete = cloudData.find(item => item.id === change.id)
                
                if (itemToDelete) {
                  // 存在，从云端删除
                  switch (collection) {
                    case 'dishes':
                      await CloudDataManager.deleteDish(change.id)
                      break
                    case 'orders':
                      await CloudDataManager.deleteData('orders', change.id)
                      break
                    case 'categories':
                      await CloudDataManager.deleteData('categories', change.id)
                      break
                    default:
                      await CloudDataManager.deleteData(collection, change.id)
                  }
                  console.log(`同步删除成功: ${collection} ${change.id}`)
                } else {
                  console.log(`要删除的数据不存在，跳过: ${collection} ${change.id}`)
                }
                break
            }
          } catch (syncError) {
            console.error(`同步变更失败: ${collection} ${change.id}`, syncError)
          }
        }
      }
      
      // 清除所有离线变更
      DataManager.clearOfflineChanges()
      
      // 重新加载最新数据
      await syncDataWithCloud()
      
      setOfflineSyncPending(false)
      
      Taro.showToast({
        title: '离线数据已同步',
        icon: 'success',
        duration: 2000
      })
    } catch (error) {
      console.error('同步离线变更失败:', error)
      dispatch({ type: 'SET_ERROR', payload: '同步离线变更失败' })
    } finally {
      dispatch({ type: 'SET_LOADING', payload: false })
    }
  }

  // 处理网络状态变化
  const handleNetworkStatusChange = (online: boolean) => {
    setIsOnline(online)
    
    // 网络恢复时，尝试同步数据
    if (online && !isInitialLoad) {
      const offlineChanges = DataManager.getOfflineChanges()
      if (offlineChanges && offlineChanges.length > 0) {
        setOfflineSyncPending(true)
        syncOfflineChanges()
      } else {
        // 检查云开发是否已初始化，避免重复调用init
        if (CloudDataManager.isCloudInitialized()) {
          syncDataWithCloud()
        } else {
          console.log('云开发未初始化，跳过网络恢复同步')
        }
      }
    }
  }

  return (
    <View className='app'>
      {/* 网络状态提示 */}
      <NetworkStatus onStatusChange={handleNetworkStatusChange} />
      
      {/* 离线同步提示 */}
      {offlineSyncPending && (
        <View className='sync-notification'>
          正在同步离线数据...
        </View>
      )}
      
      {/* 主应用内容 */}
      {children}
    </View>
  )
}

export default function App({ children }) {
  // 移除重复的云开发初始化，已在AppContent的initializeApp中处理
  return (
    <AppProvider>
      <AppContent>{children}</AppContent>
    </AppProvider>
  )
}

// 配置
App.config = {
  pages: [
    'pages/index/index',
    'pages/cart/index',
    'pages/orders/index',
    'pages/user/index',
    'pages/dish/detail',
    'pages/orders/detail',
    'pages/points/history',
    'pages/points/rules',
    'pages/settings/index'
  ],
  window: {
    backgroundTextStyle: 'light',
    navigationBarBackgroundColor: '#fff',
    navigationBarTitleText: 'WeChat',
    navigationBarTextStyle: 'black'
  },
  tabBar: {
    color: '#999',
    selectedColor: '#ff6b00',
    backgroundColor: '#fff',
    borderStyle: 'black',
    list: [
      {
        pagePath: 'pages/index/index',
        text: '菜单',
        iconPath: './assets/icons/menu.png',
        selectedIconPath: './assets/icons/menu-active.png'
      },
      {
        pagePath: 'pages/cart/index',
        text: '购物车',
        iconPath: './assets/icons/cart.png',
        selectedIconPath: './assets/icons/cart-active.png'
      },
      {
        pagePath: 'pages/orders/index',
        text: '订单',
        iconPath: './assets/icons/order.png',
        selectedIconPath: './assets/icons/order-active.png'
      },
      {
        pagePath: 'pages/user/index',
        text: '我的',
        iconPath: './assets/icons/user.png',
        selectedIconPath: './assets/icons/user-active.png'
      }
    ]
  },
  cloud: true
}
